From ba55612d48db8a4a7d55a6c7cd05ccd69761b4aa Mon Sep 17 00:00:00 2001 From: Owen Taylor Date: Wed, 21 Jun 2000 23:29:51 +0000 Subject: [PATCH] Indentation fixups to GTK+ standard. Wed Jun 21 19:29:08 2000 Owen Taylor * gdk/gdkpixbuf-render.c gdk/gdkpixbuf-drawable.c: Indentation fixups to GTK+ standard. --- ChangeLog | 5 + ChangeLog.pre-2-0 | 5 + ChangeLog.pre-2-10 | 5 + ChangeLog.pre-2-2 | 5 + ChangeLog.pre-2-4 | 5 + ChangeLog.pre-2-6 | 5 + ChangeLog.pre-2-8 | 5 + gdk/gdkpixbuf-drawable.c | 1791 ++++++++++++++++++++------------------ gdk/gdkpixbuf-render.c | 461 +++++----- 9 files changed, 1225 insertions(+), 1062 deletions(-) diff --git a/ChangeLog b/ChangeLog index 759b26d742..87c72b5135 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,8 @@ +Wed Jun 21 19:29:08 2000 Owen Taylor + + * gdk/gdkpixbuf-render.c gdk/gdkpixbuf-drawable.c: Indentation + fixups to GTK+ standard. + Wed Jun 21 16:38:13 2000 Owen Taylor * gdk-pixbuf/* docs/reference/gdk-pixbuf/*: Welcome aboard, diff --git a/ChangeLog.pre-2-0 b/ChangeLog.pre-2-0 index 759b26d742..87c72b5135 100644 --- a/ChangeLog.pre-2-0 +++ b/ChangeLog.pre-2-0 @@ -1,3 +1,8 @@ +Wed Jun 21 19:29:08 2000 Owen Taylor + + * gdk/gdkpixbuf-render.c gdk/gdkpixbuf-drawable.c: Indentation + fixups to GTK+ standard. + Wed Jun 21 16:38:13 2000 Owen Taylor * gdk-pixbuf/* docs/reference/gdk-pixbuf/*: Welcome aboard, diff --git a/ChangeLog.pre-2-10 b/ChangeLog.pre-2-10 index 759b26d742..87c72b5135 100644 --- a/ChangeLog.pre-2-10 +++ b/ChangeLog.pre-2-10 @@ -1,3 +1,8 @@ +Wed Jun 21 19:29:08 2000 Owen Taylor + + * gdk/gdkpixbuf-render.c gdk/gdkpixbuf-drawable.c: Indentation + fixups to GTK+ standard. + Wed Jun 21 16:38:13 2000 Owen Taylor * gdk-pixbuf/* docs/reference/gdk-pixbuf/*: Welcome aboard, diff --git a/ChangeLog.pre-2-2 b/ChangeLog.pre-2-2 index 759b26d742..87c72b5135 100644 --- a/ChangeLog.pre-2-2 +++ b/ChangeLog.pre-2-2 @@ -1,3 +1,8 @@ +Wed Jun 21 19:29:08 2000 Owen Taylor + + * gdk/gdkpixbuf-render.c gdk/gdkpixbuf-drawable.c: Indentation + fixups to GTK+ standard. + Wed Jun 21 16:38:13 2000 Owen Taylor * gdk-pixbuf/* docs/reference/gdk-pixbuf/*: Welcome aboard, diff --git a/ChangeLog.pre-2-4 b/ChangeLog.pre-2-4 index 759b26d742..87c72b5135 100644 --- a/ChangeLog.pre-2-4 +++ b/ChangeLog.pre-2-4 @@ -1,3 +1,8 @@ +Wed Jun 21 19:29:08 2000 Owen Taylor + + * gdk/gdkpixbuf-render.c gdk/gdkpixbuf-drawable.c: Indentation + fixups to GTK+ standard. + Wed Jun 21 16:38:13 2000 Owen Taylor * gdk-pixbuf/* docs/reference/gdk-pixbuf/*: Welcome aboard, diff --git a/ChangeLog.pre-2-6 b/ChangeLog.pre-2-6 index 759b26d742..87c72b5135 100644 --- a/ChangeLog.pre-2-6 +++ b/ChangeLog.pre-2-6 @@ -1,3 +1,8 @@ +Wed Jun 21 19:29:08 2000 Owen Taylor + + * gdk/gdkpixbuf-render.c gdk/gdkpixbuf-drawable.c: Indentation + fixups to GTK+ standard. + Wed Jun 21 16:38:13 2000 Owen Taylor * gdk-pixbuf/* docs/reference/gdk-pixbuf/*: Welcome aboard, diff --git a/ChangeLog.pre-2-8 b/ChangeLog.pre-2-8 index 759b26d742..87c72b5135 100644 --- a/ChangeLog.pre-2-8 +++ b/ChangeLog.pre-2-8 @@ -1,3 +1,8 @@ +Wed Jun 21 19:29:08 2000 Owen Taylor + + * gdk/gdkpixbuf-render.c gdk/gdkpixbuf-drawable.c: Indentation + fixups to GTK+ standard. + Wed Jun 21 16:38:13 2000 Owen Taylor * gdk-pixbuf/* docs/reference/gdk-pixbuf/*: Welcome aboard, diff --git a/gdk/gdkpixbuf-drawable.c b/gdk/gdkpixbuf-drawable.c index 955a8f5c5d..ec208da03d 100644 --- a/gdk/gdkpixbuf-drawable.c +++ b/gdk/gdkpixbuf-drawable.c @@ -1,4 +1,3 @@ -/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */ /* GdkPixbuf library - convert X drawable information to RGB * * Copyright (C) 1999 Michael Zucchi @@ -42,995 +41,1099 @@ static guint32 mask_table[] = { - 0x00000000, 0x00000001, 0x00000003, 0x00000007, - 0x0000000f, 0x0000001f, 0x0000003f, 0x0000007f, - 0x000000ff, 0x000001ff, 0x000003ff, 0x000007ff, - 0x00000fff, 0x00001fff, 0x00003fff, 0x00007fff, - 0x0000ffff, 0x0001ffff, 0x0003ffff, 0x0007ffff, - 0x000fffff, 0x001fffff, 0x003fffff, 0x007fffff, - 0x00ffffff, 0x01ffffff, 0x03ffffff, 0x07ffffff, - 0x0fffffff, 0x1fffffff, 0x3fffffff, 0x7fffffff, - 0xffffffff + 0x00000000, 0x00000001, 0x00000003, 0x00000007, + 0x0000000f, 0x0000001f, 0x0000003f, 0x0000007f, + 0x000000ff, 0x000001ff, 0x000003ff, 0x000007ff, + 0x00000fff, 0x00001fff, 0x00003fff, 0x00007fff, + 0x0000ffff, 0x0001ffff, 0x0003ffff, 0x0007ffff, + 0x000fffff, 0x001fffff, 0x003fffff, 0x007fffff, + 0x00ffffff, 0x01ffffff, 0x03ffffff, 0x07ffffff, + 0x0fffffff, 0x1fffffff, 0x3fffffff, 0x7fffffff, + 0xffffffff }; /* - convert 1 bits-pixel data - no alpha -*/ + * convert 1 bits-pixel data + * no alpha + */ static void -rgb1 (GdkImage *image, guchar *pixels, int rowstride, GdkColormap *colormap) +rgb1 (GdkImage *image, + guchar *pixels, + int rowstride, + GdkColormap *colormap) { - int xx, yy; - int width, height; - int bpl; - guint8 *s; - register guint8 data; - guint8 *o; - guint8 *srow = image->mem, *orow = pixels; - - d (printf ("1 bits/pixel\n")); - - /* convert upto 8 pixels/time */ - /* its probably not worth trying to make this run very fast, who uses - 1 bit displays anymore? */ - width = image->width; - height = image->height; - bpl = image->bpl; - - for (yy = 0; yy < height; yy++) { - s = srow; - o = orow; - - for (xx = 0; xx < width; xx ++) { - data = srow[xx >> 3] >> (7 - (xx & 7)) & 1; - *o++ = colormap->colors[data].red; - *o++ = colormap->colors[data].green; - *o++ = colormap->colors[data].blue; - } - srow += bpl; - orow += rowstride; + int xx, yy; + int width, height; + int bpl; + guint8 *s; + register guint8 data; + guint8 *o; + guint8 *srow = image->mem, *orow = pixels; + + d (printf ("1 bits/pixel\n")); + + /* convert upto 8 pixels/time */ + /* its probably not worth trying to make this run very fast, who uses + * 1 bit displays anymore? + */ + width = image->width; + height = image->height; + bpl = image->bpl; + + for (yy = 0; yy < height; yy++) + { + s = srow; + o = orow; + + for (xx = 0; xx < width; xx ++) + { + data = srow[xx >> 3] >> (7 - (xx & 7)) & 1; + *o++ = colormap->colors[data].red; + *o++ = colormap->colors[data].green; + *o++ = colormap->colors[data].blue; } + srow += bpl; + orow += rowstride; + } } /* - convert 1 bits/pixel data - with alpha -*/ + * convert 1 bits/pixel data + * with alpha + */ static void -rgb1a (GdkImage *image, guchar *pixels, int rowstride, GdkColormap *colormap) +rgb1a (GdkImage *image, + guchar *pixels, + int rowstride, + GdkColormap *colormap) { - int xx, yy; - int width, height; - int bpl; - guint8 *s; - register guint8 data; - guint8 *o; - guint8 *srow = image->mem, *orow = pixels; - guint32 remap[2]; - - d (printf ("1 bits/pixel\n")); - - /* convert upto 8 pixels/time */ - /* its probably not worth trying to make this run very fast, who uses - 1 bit displays anymore? */ - width = image->width; - height = image->height; - bpl = image->bpl; - - for (xx = 0; xx < 2; xx++) { + int xx, yy; + int width, height; + int bpl; + guint8 *s; + register guint8 data; + guint8 *o; + guint8 *srow = image->mem, *orow = pixels; + guint32 remap[2]; + + d (printf ("1 bits/pixel\n")); + + /* convert upto 8 pixels/time */ + /* its probably not worth trying to make this run very fast, who uses + * 1 bit displays anymore? */ + width = image->width; + height = image->height; + bpl = image->bpl; + + for (xx = 0; xx < 2; xx++) + { #ifdef LITTLE - remap[xx] = 0xff000000 - | colormap->colors[xx].blue << 16 - | colormap->colors[xx].green << 8 - | colormap->colors[xx].red; + remap[xx] = 0xff000000 + | colormap->colors[xx].blue << 16 + | colormap->colors[xx].green << 8 + | colormap->colors[xx].red; #else - remap[xx] = 0xff - | colormap->colors[xx].red << 24 - | colormap->colors[xx].green << 16 - | colormap->colors[xx].blue << 8; + remap[xx] = 0xff + | colormap->colors[xx].red << 24 + | colormap->colors[xx].green << 16 + | colormap->colors[xx].blue << 8; #endif + } + + for (yy = 0; yy < height; yy++) + { + s = srow; + o = orow; + + for (xx = 0; xx < width; xx ++) + { + data = srow[xx >> 3] >> (7 - (xx & 7)) & 1; + *o++ = remap[data]; } - - for (yy = 0; yy < height; yy++) { - s = srow; - o = orow; - - for (xx = 0; xx < width; xx ++) { - data = srow[xx >> 3] >> (7 - (xx & 7)) & 1; - *o++ = remap[data]; - } - srow += bpl; - orow += rowstride; - } + srow += bpl; + orow += rowstride; + } } /* - convert 8 bits/pixel data - no alpha -*/ + * convert 8 bits/pixel data + * no alpha + */ static void -rgb8 (GdkImage *image, guchar *pixels, int rowstride, GdkColormap *colormap) +rgb8 (GdkImage *image, + guchar *pixels, + int rowstride, + GdkColormap *colormap) { - int xx, yy; - int width, height; - int bpl; - guint32 mask; - register guint32 data; - guint8 *srow = image->mem, *orow = pixels; - register guint8 *s; - register guint8 *o; - - width = image->width; - height = image->height; - bpl = image->bpl; - - d (printf ("8 bit, no alpha output\n")); - - mask = mask_table[image->depth]; - - for (yy = 0; yy < height; yy++) { - s = srow; - o = orow; - for (xx = 0; xx < width; xx++) { - data = *s++ & mask; - *o++ = colormap->colors[data].red; - *o++ = colormap->colors[data].green; - *o++ = colormap->colors[data].blue; - } - srow += bpl; - orow += rowstride; - } + int xx, yy; + int width, height; + int bpl; + guint32 mask; + register guint32 data; + guint8 *srow = image->mem, *orow = pixels; + register guint8 *s; + register guint8 *o; + + width = image->width; + height = image->height; + bpl = image->bpl; + + d (printf ("8 bit, no alpha output\n")); + + mask = mask_table[image->depth]; + + for (yy = 0; yy < height; yy++) + { + s = srow; + o = orow; + for (xx = 0; xx < width; xx++) { + data = *s++ & mask; + *o++ = colormap->colors[data].red; + *o++ = colormap->colors[data].green; + *o++ = colormap->colors[data].blue; + } + srow += bpl; + orow += rowstride; + } } /* - convert 8 bits/pixel data - with alpha -*/ + * convert 8 bits/pixel data + * with alpha + */ static void -rgb8a (GdkImage *image, guchar *pixels, int rowstride, GdkColormap *colormap) +rgb8a (GdkImage *image, + guchar *pixels, + int rowstride, + GdkColormap *colormap) { - int xx, yy; - int width, height; - int bpl; - guint32 mask; - register guint32 data; - guint32 remap[256]; - register guint8 *s; /* read 2 pixels at once */ - register guint32 *o; - guint8 *srow = image->mem, *orow = pixels; - - width = image->width; - height = image->height; - bpl = image->bpl; - - d (printf ("8 bit, with alpha output\n")); - - mask = mask_table[image->depth]; - - for (xx = 0; xx < colormap->size; xx++) { + int xx, yy; + int width, height; + int bpl; + guint32 mask; + register guint32 data; + guint32 remap[256]; + register guint8 *s; /* read 2 pixels at once */ + register guint32 *o; + guint8 *srow = image->mem, *orow = pixels; + + width = image->width; + height = image->height; + bpl = image->bpl; + + d (printf ("8 bit, with alpha output\n")); + + mask = mask_table[image->depth]; + + for (xx = 0; xx < colormap->size; xx++) + { #ifdef LITTLE - remap[xx] = 0xff000000 - | colormap->colors[xx].blue << 16 - | colormap->colors[xx].green << 8 - | colormap->colors[xx].red; + remap[xx] = 0xff000000 + | colormap->colors[xx].blue << 16 + | colormap->colors[xx].green << 8 + | colormap->colors[xx].red; #else - remap[xx] = 0xff - | colormap->colors[xx].red << 24 - | colormap->colors[xx].green << 16 - | colormap->colors[xx].blue << 8; + remap[xx] = 0xff + | colormap->colors[xx].red << 24 + | colormap->colors[xx].green << 16 + | colormap->colors[xx].blue << 8; #endif + } + + for (yy = 0; yy < height; yy++) + { + s = srow; + o = (guint32 *) orow; + for (xx = 0; xx < width; xx ++) + { + data = *s++ & mask; + *o++ = remap[data]; } - - for (yy = 0; yy < height; yy++) { - s = srow; - o = (guint32 *) orow; - for (xx = 0; xx < width; xx ++) { - data = *s++ & mask; - *o++ = remap[data]; - } - srow += bpl; - orow += rowstride; - } + srow += bpl; + orow += rowstride; + } } /* - convert 16 bits/pixel data - no alpha - data in lsb format -*/ + * convert 16 bits/pixel data + * no alpha + * data in lsb format + */ static void -rgb565lsb (GdkImage *image, guchar *pixels, int rowstride, GdkColormap *colormap) +rgb565lsb (GdkImage *image, + guchar *pixels, + int rowstride, + GdkColormap *colormap) { - int xx, yy; - int width, height; - int bpl; + int xx, yy; + int width, height; + int bpl; #ifdef LITTLE - register guint32 *s; /* read 2 pixels at once */ + register guint32 *s; /* read 2 pixels at once */ #else - register guint8 *s; /* read 2 pixels at once */ + register guint8 *s; /* read 2 pixels at once */ #endif - register guint16 *o; - guint8 *srow = image->mem, *orow = pixels; + register guint16 *o; + guint8 *srow = image->mem, *orow = pixels; - width = image->width; - height = image->height; - bpl = image->bpl; + width = image->width; + height = image->height; + bpl = image->bpl; - for (yy = 0; yy < height; yy++) { + for (yy = 0; yy < height; yy++) + { #ifdef LITTLE - s = (guint32 *) srow; + s = (guint32 *) srow; #else - s = srow; + s = srow; #endif - o = (guint16 *) orow; - for (xx = 1; xx < width; xx += 2) { - register guint32 data; + o = (guint16 *) orow; + for (xx = 1; xx < width; xx += 2) + { + register guint32 data; #ifdef LITTLE - data = *s++; - *o++ = (data & 0xf800) >> 8 | (data & 0xe000) >> 13 - | (data & 0x7e0) << 5 | (data & 0x600) >> 1; - *o++ = (data & 0x1f) << 3 | (data & 0x1c) >> 2 - | (data & 0xf8000000) >> 16 | (data & 0xe0000000) >> 21; - *o++ = (data & 0x7e00000) >> 19 | (data & 0x6000000) >> 25 - | (data & 0x1f0000) >> 5 | (data & 0x1c0000) >> 10; + data = *s++; + *o++ = (data & 0xf800) >> 8 | (data & 0xe000) >> 13 + | (data & 0x7e0) << 5 | (data & 0x600) >> 1; + *o++ = (data & 0x1f) << 3 | (data & 0x1c) >> 2 + | (data & 0xf8000000) >> 16 | (data & 0xe0000000) >> 21; + *o++ = (data & 0x7e00000) >> 19 | (data & 0x6000000) >> 25 + | (data & 0x1f0000) >> 5 | (data & 0x1c0000) >> 10; #else - /* swap endianness first */ - data = s[0] | s[1] << 8 | s[2] << 16 | s[3] << 24; - s += 4; - *o++ = (data & 0xf800) | (data & 0xe000) >> 5 - | (data & 0x7e0) >> 3 | (data & 0x600) >> 9; - *o++ = (data & 0x1f) << 11 | (data & 0x1c) << 6 - | (data & 0xf8000000) >> 24 | (data & 0xe0000000) >> 29; - *o++ = (data & 0x7e00000) >> 11 | (data & 0x6000000) >> 17 - | (data & 0x1f0000) >> 13 | (data & 0x1c0000) >> 18; + /* swap endianness first */ + data = s[0] | s[1] << 8 | s[2] << 16 | s[3] << 24; + s += 4; + *o++ = (data & 0xf800) | (data & 0xe000) >> 5 + | (data & 0x7e0) >> 3 | (data & 0x600) >> 9; + *o++ = (data & 0x1f) << 11 | (data & 0x1c) << 6 + | (data & 0xf8000000) >> 24 | (data & 0xe0000000) >> 29; + *o++ = (data & 0x7e00000) >> 11 | (data & 0x6000000) >> 17 + | (data & 0x1f0000) >> 13 | (data & 0x1c0000) >> 18; #endif - } - /* check for last remaining pixel */ - if (width & 1) { - register guint16 data; + } + /* check for last remaining pixel */ + if (width & 1) + { + register guint16 data; #ifdef LITTLE - data = *((short *) s); + data = *((short *) s); #else - data = *((short *) s); - data = ((data >> 8) & 0xff) | ((data & 0xff) << 8); + data = *((short *) s); + data = ((data >> 8) & 0xff) | ((data & 0xff) << 8); #endif - ((char *) o)[0] = ((data >> 8) & 0xf8) | ((data >> 13) & 0x7); - ((char *) o)[1] = ((data >> 3) & 0xfc) | ((data >> 9) & 0x3); - ((char *) o)[2] = ((data << 3) & 0xf8) | ((data >> 2) & 0x7); - } - srow += bpl; - orow += rowstride; + ((char *) o)[0] = ((data >> 8) & 0xf8) | ((data >> 13) & 0x7); + ((char *) o)[1] = ((data >> 3) & 0xfc) | ((data >> 9) & 0x3); + ((char *) o)[2] = ((data << 3) & 0xf8) | ((data >> 2) & 0x7); } + srow += bpl; + orow += rowstride; + } } /* - convert 16 bits/pixel data - no alpha - data in msb format -*/ + * convert 16 bits/pixel data + * no alpha + * data in msb format + */ static void -rgb565msb (GdkImage *image, guchar *pixels, int rowstride, GdkColormap *colormap) +rgb565msb (GdkImage *image, + guchar *pixels, + int rowstride, + GdkColormap *colormap) { - int xx, yy; - int width, height; - int bpl; + int xx, yy; + int width, height; + int bpl; #ifdef LITTLE - register guint8 *s; /* need to swap data order */ + register guint8 *s; /* need to swap data order */ #else - register guint32 *s; /* read 2 pixels at once */ + register guint32 *s; /* read 2 pixels at once */ #endif - register guint16 *o; - guint8 *srow = image->mem, *orow = pixels; + register guint16 *o; + guint8 *srow = image->mem, *orow = pixels; - width = image->width; - height = image->height; - bpl = image->bpl; + width = image->width; + height = image->height; + bpl = image->bpl; - for (yy = 0; yy < height; yy++) { + for (yy = 0; yy < height; yy++) + { #ifdef LITTLE - s = srow; + s = srow; #else - s = (guint32 *) srow; + s = (guint32 *) srow; #endif - o = (guint16 *) orow; - for (xx = 1; xx < width; xx += 2) { - register guint32 data; + o = (guint16 *) orow; + for (xx = 1; xx < width; xx += 2) + { + register guint32 data; #ifdef LITTLE - /* swap endianness first */ - data = s[0] | s[1] << 8 | s[2] << 16 | s[3] << 24; - s += 4; - *o++ = (data & 0xf800) >> 8 | (data & 0xe000) >> 13 - | (data & 0x7e0) << 5 | (data & 0x600) >> 1; - *o++ = (data & 0x1f) << 3 | (data & 0x1c) >> 2 - | (data & 0xf8000000) >> 16 | (data & 0xe0000000) >> 21; - *o++ = (data & 0x7e00000) >> 19 | (data & 0x6000000) >> 25 - | (data & 0x1f0000) >> 5 | (data & 0x1c0000) >> 10; + /* swap endianness first */ + data = s[0] | s[1] << 8 | s[2] << 16 | s[3] << 24; + s += 4; + *o++ = (data & 0xf800) >> 8 | (data & 0xe000) >> 13 + | (data & 0x7e0) << 5 | (data & 0x600) >> 1; + *o++ = (data & 0x1f) << 3 | (data & 0x1c) >> 2 + | (data & 0xf8000000) >> 16 | (data & 0xe0000000) >> 21; + *o++ = (data & 0x7e00000) >> 19 | (data & 0x6000000) >> 25 + | (data & 0x1f0000) >> 5 | (data & 0x1c0000) >> 10; #else - data = *s++; - *o++ = (data & 0xf800) | (data & 0xe000) >> 5 - | (data & 0x7e0) >> 3 | (data & 0x600) >> 9; - *o++ = (data & 0x1f) << 11 | (data & 0x1c) << 6 - | (data & 0xf8000000) >> 24 | (data & 0xe0000000) >> 29; - *o++ = (data & 0x7e00000) >> 11 | (data & 0x6000000) >> 17 - | (data & 0x1f0000) >> 13 | (data & 0x1c0000) >> 18; + data = *s++; + *o++ = (data & 0xf800) | (data & 0xe000) >> 5 + | (data & 0x7e0) >> 3 | (data & 0x600) >> 9; + *o++ = (data & 0x1f) << 11 | (data & 0x1c) << 6 + | (data & 0xf8000000) >> 24 | (data & 0xe0000000) >> 29; + *o++ = (data & 0x7e00000) >> 11 | (data & 0x6000000) >> 17 + | (data & 0x1f0000) >> 13 | (data & 0x1c0000) >> 18; #endif - } - /* check for last remaining pixel */ - if (width & 1) { - register guint16 data; + } + /* check for last remaining pixel */ + if (width & 1) + { + register guint16 data; #ifdef LITTLE - data = *((short *) s); - data = ((data >> 8) & 0xff) | ((data & 0xff) << 8); + data = *((short *) s); + data = ((data >> 8) & 0xff) | ((data & 0xff) << 8); #else - data = *((short *) s); + data = *((short *) s); #endif - ((char *) o)[0] = ((data >> 8) & 0xf8) | ((data >> 13) & 0x7); - ((char *) o)[1] = ((data >> 3) & 0xfc) | ((data >> 9) & 0x3); - ((char *) o)[2] = ((data << 3) & 0xf8) | ((data >> 2) & 0x7); - } - srow += bpl; - orow += rowstride; + ((char *) o)[0] = ((data >> 8) & 0xf8) | ((data >> 13) & 0x7); + ((char *) o)[1] = ((data >> 3) & 0xfc) | ((data >> 9) & 0x3); + ((char *) o)[2] = ((data << 3) & 0xf8) | ((data >> 2) & 0x7); } + srow += bpl; + orow += rowstride; + } } /* - convert 16 bits/pixel data - with alpha - data in lsb format -*/ + * convert 16 bits/pixel data + * with alpha + * data in lsb format + */ static void -rgb565alsb (GdkImage *image, guchar *pixels, int rowstride, GdkColormap *colormap) +rgb565alsb (GdkImage *image, + guchar *pixels, + int rowstride, + GdkColormap *colormap) { - int xx, yy; - int width, height; - int bpl; + int xx, yy; + int width, height; + int bpl; #ifdef LITTLE - register guint16 *s; /* read 1 pixels at once */ + register guint16 *s; /* read 1 pixels at once */ #else - register guint8 *s; + register guint8 *s; #endif - register guint32 *o; + register guint32 *o; - guint8 *srow = image->mem, *orow = pixels; + guint8 *srow = image->mem, *orow = pixels; - width = image->width; - height = image->height; - bpl = image->bpl; + width = image->width; + height = image->height; + bpl = image->bpl; - for (yy = 0; yy < height; yy++) { + for (yy = 0; yy < height; yy++) + { #ifdef LITTLE - s = (guint16 *) srow; + s = (guint16 *) srow; #else - s = (guint8 *) srow; + s = (guint8 *) srow; #endif - o = (guint32 *) orow; - for (xx = 0; xx < width; xx ++) { - register guint32 data; - /* rrrrrggg gggbbbbb -> rrrrrRRR ggggggGG bbbbbBBB aaaaaaaa */ - /* little endian: aaaaaaaa bbbbbBBB ggggggGG rrrrrRRR */ + o = (guint32 *) orow; + for (xx = 0; xx < width; xx ++) + { + register guint32 data; + /* rrrrrggg gggbbbbb -> rrrrrRRR ggggggGG bbbbbBBB aaaaaaaa */ + /* little endian: aaaaaaaa bbbbbBBB ggggggGG rrrrrRRR */ #ifdef LITTLE - data = *s++; - *o++ = (data & 0xf800) >> 8 | (data & 0xe000) >> 13 - | (data & 0x7e0) << 5 | (data & 0x600) >> 1 - | (data & 0x1f) << 19 | (data & 0x1c) << 14 - | 0xff000000; + data = *s++; + *o++ = (data & 0xf800) >> 8 | (data & 0xe000) >> 13 + | (data & 0x7e0) << 5 | (data & 0x600) >> 1 + | (data & 0x1f) << 19 | (data & 0x1c) << 14 + | 0xff000000; #else - /* swap endianness first */ - data = s[0] | s[1] << 8; - s += 2; - *o++ = (data & 0xf800) << 16 | (data & 0xe000) << 11 - | (data & 0x7e0) << 13 | (data & 0x600) << 7 - | (data & 0x1f) << 11 | (data & 0x1c) << 6 - | 0xff; + /* swap endianness first */ + data = s[0] | s[1] << 8; + s += 2; + *o++ = (data & 0xf800) << 16 | (data & 0xe000) << 11 + | (data & 0x7e0) << 13 | (data & 0x600) << 7 + | (data & 0x1f) << 11 | (data & 0x1c) << 6 + | 0xff; #endif - } - srow += bpl; - orow += rowstride; } + srow += bpl; + orow += rowstride; + } } /* - convert 16 bits/pixel data - with alpha - data in msb format -*/ + * convert 16 bits/pixel data + * with alpha + * data in msb format + */ static void -rgb565amsb (GdkImage *image, guchar *pixels, int rowstride, GdkColormap *colormap) +rgb565amsb (GdkImage *image, + guchar *pixels, + int rowstride, + GdkColormap *colormap) { - int xx, yy; - int width, height; - int bpl; + int xx, yy; + int width, height; + int bpl; #ifdef LITTLE - register guint8 *s; + register guint8 *s; #else - register guint16 *s; /* read 1 pixels at once */ + register guint16 *s; /* read 1 pixels at once */ #endif - register guint32 *o; - - guint8 *srow = image->mem, *orow = pixels; - - width = image->width; - height = image->height; - bpl = image->bpl; - - for (yy = 0; yy < height; yy++) { - s = srow; - o = (guint32 *) orow; - for (xx = 0; xx < width; xx ++) { - register guint32 data; - /* rrrrrggg gggbbbbb -> rrrrrRRR gggggg00 bbbbbBBB aaaaaaaa */ - /* little endian: aaaaaaaa bbbbbBBB gggggg00 rrrrrRRR */ + register guint32 *o; + + guint8 *srow = image->mem, *orow = pixels; + + width = image->width; + height = image->height; + bpl = image->bpl; + + for (yy = 0; yy < height; yy++) + { + s = srow; + o = (guint32 *) orow; + for (xx = 0; xx < width; xx ++) + { + register guint32 data; + /* rrrrrggg gggbbbbb -> rrrrrRRR gggggg00 bbbbbBBB aaaaaaaa */ + /* little endian: aaaaaaaa bbbbbBBB gggggg00 rrrrrRRR */ #ifdef LITTLE - /* swap endianness first */ - data = s[0] | s[1] << 8; - s += 2; - *o++ = (data & 0xf800) >> 8 | (data & 0xe000) >> 13 - | (data & 0x7e0) << 5 | (data & 0x600) >> 1 - | (data & 0x1f) << 19 | (data & 0x1c) << 14 - | 0xff000000; + /* swap endianness first */ + data = s[0] | s[1] << 8; + s += 2; + *o++ = (data & 0xf800) >> 8 | (data & 0xe000) >> 13 + | (data & 0x7e0) << 5 | (data & 0x600) >> 1 + | (data & 0x1f) << 19 | (data & 0x1c) << 14 + | 0xff000000; #else - data = *s++; - *o++ = (data & 0xf800) << 16 | (data & 0xe000) << 11 - | (data & 0x7e0) << 13 | (data & 0x600) << 7 - | (data & 0x1f) << 11 | (data & 0x1c) << 6 - | 0xff; + data = *s++; + *o++ = (data & 0xf800) << 16 | (data & 0xe000) << 11 + | (data & 0x7e0) << 13 | (data & 0x600) << 7 + | (data & 0x1f) << 11 | (data & 0x1c) << 6 + | 0xff; #endif - } - srow += bpl; - orow += rowstride; } + srow += bpl; + orow += rowstride; + } } /* - convert 15 bits/pixel data - no alpha - data in lsb format -*/ + * convert 15 bits/pixel data + * no alpha + * data in lsb format + */ static void -rgb555lsb (GdkImage *image, guchar *pixels, int rowstride, GdkColormap *colormap) +rgb555lsb (GdkImage *image, + guchar *pixels, + int rowstride, + GdkColormap *colormap) { - int xx, yy; - int width, height; - int bpl; + int xx, yy; + int width, height; + int bpl; #ifdef LITTLE - register guint32 *s; /* read 2 pixels at once */ + register guint32 *s; /* read 2 pixels at once */ #else - register guint8 *s; /* read 2 pixels at once */ + register guint8 *s; /* read 2 pixels at once */ #endif - register guint16 *o; - guint8 *srow = image->mem, *orow = pixels; + register guint16 *o; + guint8 *srow = image->mem, *orow = pixels; - width = image->width; - height = image->height; - bpl = image->bpl; + width = image->width; + height = image->height; + bpl = image->bpl; - for (yy = 0; yy < height; yy++) { + for (yy = 0; yy < height; yy++) + { #ifdef LITTLE - s = (guint32 *) srow; + s = (guint32 *) srow; #else - s = srow; + s = srow; #endif - o = (guint16 *) orow; - for (xx = 1; xx < width; xx += 2) { - register guint32 data; + o = (guint16 *) orow; + for (xx = 1; xx < width; xx += 2) + { + register guint32 data; #ifdef LITTLE - data = *s++; - *o++ = (data & 0x7c00) >> 7 | (data & 0x7000) >> 12 - | (data & 0x3e0) << 6 | (data & 0x380) << 1; - *o++ = (data & 0x1f) << 3 | (data & 0x1c) >> 2 - | (data & 0x7c000000) >> 15 | (data & 0x70000000) >> 20; - *o++ = (data & 0x3e00000) >> 18 | (data & 0x3800000) >> 23 - | (data & 0x1f0000) >> 5 | (data & 0x1c0000) >> 10; + data = *s++; + *o++ = (data & 0x7c00) >> 7 | (data & 0x7000) >> 12 + | (data & 0x3e0) << 6 | (data & 0x380) << 1; + *o++ = (data & 0x1f) << 3 | (data & 0x1c) >> 2 + | (data & 0x7c000000) >> 15 | (data & 0x70000000) >> 20; + *o++ = (data & 0x3e00000) >> 18 | (data & 0x3800000) >> 23 + | (data & 0x1f0000) >> 5 | (data & 0x1c0000) >> 10; #else - /* swap endianness first */ - data = s[0] | s[1] << 8 | s[2] << 16 | s[3] << 24; - s += 4; - *o++ = (data & 0x7c00) << 1 | (data & 0x7000) >> 4 - | (data & 0x3e0) >> 2 | (data & 0x380) >> 7; - *o++ = (data & 0x1f) << 11 | (data & 0x1c) << 6 - | (data & 0x7c000000) >> 23 | (data & 0x70000000) >> 28; - *o++ = (data & 0x3e00000) >> 10 | (data & 0x3800000) >> 15 - | (data & 0x1f0000) >> 13 | (data & 0x1c0000) >> 18; + /* swap endianness first */ + data = s[0] | s[1] << 8 | s[2] << 16 | s[3] << 24; + s += 4; + *o++ = (data & 0x7c00) << 1 | (data & 0x7000) >> 4 + | (data & 0x3e0) >> 2 | (data & 0x380) >> 7; + *o++ = (data & 0x1f) << 11 | (data & 0x1c) << 6 + | (data & 0x7c000000) >> 23 | (data & 0x70000000) >> 28; + *o++ = (data & 0x3e00000) >> 10 | (data & 0x3800000) >> 15 + | (data & 0x1f0000) >> 13 | (data & 0x1c0000) >> 18; #endif - } - /* check for last remaining pixel */ - if (width & 1) { - register guint16 data; + } + /* check for last remaining pixel */ + if (width & 1) + { + register guint16 data; #ifdef LITTLE - data = *((short *) s); + data = *((short *) s); #else - data = *((short *) s); - data = ((data >> 8) & 0xff) | ((data & 0xff) << 8); + data = *((short *) s); + data = ((data >> 8) & 0xff) | ((data & 0xff) << 8); #endif - ((char *) o)[0] = (data & 0x7c00) >> 7 | (data & 0x7000) >> 12; - ((char *) o)[1] = (data & 0x3e0) >> 2 | (data & 0x380) >> 7; - ((char *) o)[2] = (data & 0x1f) << 3 | (data & 0x1c) >> 2; - } - srow += bpl; - orow += rowstride; + ((char *) o)[0] = (data & 0x7c00) >> 7 | (data & 0x7000) >> 12; + ((char *) o)[1] = (data & 0x3e0) >> 2 | (data & 0x380) >> 7; + ((char *) o)[2] = (data & 0x1f) << 3 | (data & 0x1c) >> 2; } + srow += bpl; + orow += rowstride; + } } /* - convert 15 bits/pixel data - no alpha - data in msb format -*/ + * convert 15 bits/pixel data + * no alpha + * data in msb format + */ static void -rgb555msb (GdkImage *image, guchar *pixels, int rowstride, GdkColormap *colormap) +rgb555msb (GdkImage *image, + guchar *pixels, + int rowstride, + GdkColormap *colormap) { - int xx, yy; - int width, height; - int bpl; + int xx, yy; + int width, height; + int bpl; #ifdef LITTLE - register guint8 *s; /* read 2 pixels at once */ + register guint8 *s; /* read 2 pixels at once */ #else - register guint32 *s; /* read 2 pixels at once */ + register guint32 *s; /* read 2 pixels at once */ #endif - register guint16 *o; - guint8 *srow = image->mem, *orow = pixels; - - width = image->width; - height = image->height; - bpl = image->bpl; - - for (yy = 0; yy < height; yy++) { - s = srow; - o = (guint16 *) orow; - for (xx = 1; xx < width; xx += 2) { - register guint32 data; + register guint16 *o; + guint8 *srow = image->mem, *orow = pixels; + + width = image->width; + height = image->height; + bpl = image->bpl; + + for (yy = 0; yy < height; yy++) + { + s = srow; + o = (guint16 *) orow; + for (xx = 1; xx < width; xx += 2) + { + register guint32 data; #ifdef LITTLE - /* swap endianness first */ - data = s[0] | s[1] << 8 | s[2] << 16 | s[3] << 24; - s += 4; - *o++ = (data & 0x7c00) >> 7 | (data & 0x7000) >> 12 - | (data & 0x3e0) << 6 | (data & 0x380) << 1; - *o++ = (data & 0x1f) << 3 | (data & 0x1c) >> 2 - | (data & 0x7c000000) >> 15 | (data & 0x70000000) >> 20; - *o++ = (data & 0x3e00000) >> 18 | (data & 0x3800000) >> 23 - | (data & 0x1f0000) >> 5 | (data & 0x1c0000) >> 10; + /* swap endianness first */ + data = s[0] | s[1] << 8 | s[2] << 16 | s[3] << 24; + s += 4; + *o++ = (data & 0x7c00) >> 7 | (data & 0x7000) >> 12 + | (data & 0x3e0) << 6 | (data & 0x380) << 1; + *o++ = (data & 0x1f) << 3 | (data & 0x1c) >> 2 + | (data & 0x7c000000) >> 15 | (data & 0x70000000) >> 20; + *o++ = (data & 0x3e00000) >> 18 | (data & 0x3800000) >> 23 + | (data & 0x1f0000) >> 5 | (data & 0x1c0000) >> 10; #else - data = *s++; - *o++ = (data & 0x7c00) << 1 | (data & 0x7000) >> 4 - | (data & 0x3e0) >> 2 | (data & 0x380) >> 7; - *o++ = (data & 0x1f) << 11 | (data & 0x1c) << 6 - | (data & 0x7c000000) >> 23 | (data & 0x70000000) >> 28; - *o++ = (data & 0x3e00000) >> 10 | (data & 0x3800000) >> 15 - | (data & 0x1f0000) >> 13 | (data & 0x1c0000) >> 18; + data = *s++; + *o++ = (data & 0x7c00) << 1 | (data & 0x7000) >> 4 + | (data & 0x3e0) >> 2 | (data & 0x380) >> 7; + *o++ = (data & 0x1f) << 11 | (data & 0x1c) << 6 + | (data & 0x7c000000) >> 23 | (data & 0x70000000) >> 28; + *o++ = (data & 0x3e00000) >> 10 | (data & 0x3800000) >> 15 + | (data & 0x1f0000) >> 13 | (data & 0x1c0000) >> 18; #endif - } - /* check for last remaining pixel */ - if (width & 1) { - register guint16 data; + } + /* check for last remaining pixel */ + if (width & 1) + { + register guint16 data; #ifdef LITTLE - data = *((short *) s); - data = ((data >> 8) & 0xff) | ((data & 0xff) << 8); + data = *((short *) s); + data = ((data >> 8) & 0xff) | ((data & 0xff) << 8); #else - data = *((short *) s); + data = *((short *) s); #endif - ((char *) o)[0] = (data & 0x7c00) >> 7 | (data & 0x7000) >> 12; - ((char *) o)[1] = (data & 0x3e0) >> 2 | (data & 0x380) >> 7; - ((char *) o)[2] = (data & 0x1f) << 3 | (data & 0x1c) >> 2; - } - srow += bpl; - orow += rowstride; + ((char *) o)[0] = (data & 0x7c00) >> 7 | (data & 0x7000) >> 12; + ((char *) o)[1] = (data & 0x3e0) >> 2 | (data & 0x380) >> 7; + ((char *) o)[2] = (data & 0x1f) << 3 | (data & 0x1c) >> 2; } + srow += bpl; + orow += rowstride; + } } /* - convert 15 bits/pixel data - with alpha - data in lsb format -*/ + * convert 15 bits/pixel data + * with alpha + * data in lsb format + */ static void -rgb555alsb (GdkImage *image, guchar *pixels, int rowstride, GdkColormap *colormap) +rgb555alsb (GdkImage *image, + guchar *pixels, + int rowstride, + GdkColormap *colormap) { - int xx, yy; - int width, height; - int bpl; + int xx, yy; + int width, height; + int bpl; #ifdef LITTLE - register guint16 *s; /* read 1 pixels at once */ + register guint16 *s; /* read 1 pixels at once */ #else - register guint8 *s; + register guint8 *s; #endif - register guint32 *o; + register guint32 *o; - guint8 *srow = image->mem, *orow = pixels; + guint8 *srow = image->mem, *orow = pixels; - width = image->width; - height = image->height; - bpl = image->bpl; + width = image->width; + height = image->height; + bpl = image->bpl; - for (yy = 0; yy < height; yy++) { + for (yy = 0; yy < height; yy++) + { #ifdef LITTLE - s = (guint16 *) srow; + s = (guint16 *) srow; #else - s = srow; + s = srow; #endif - o = (guint32 *) orow; - for (xx = 0; xx < width; xx++) { - register guint32 data; - /* rrrrrggg gggbbbbb -> rrrrrRRR gggggGGG bbbbbBBB aaaaaaaa */ - /* little endian: aaaaaaaa bbbbbBBB gggggGGG rrrrrRRR */ + o = (guint32 *) orow; + for (xx = 0; xx < width; xx++) + { + register guint32 data; + /* rrrrrggg gggbbbbb -> rrrrrRRR gggggGGG bbbbbBBB aaaaaaaa */ + /* little endian: aaaaaaaa bbbbbBBB gggggGGG rrrrrRRR */ #ifdef LITTLE - data = *s++; - *o++ = (data & 0x7c00) >> 7 | (data & 0x7000) >> 12 - | (data & 0x3e0) << 6 | (data & 0x380) << 1 - | (data & 0x1f) << 19 | (data & 0x1c) << 14 - | 0xff000000; + data = *s++; + *o++ = (data & 0x7c00) >> 7 | (data & 0x7000) >> 12 + | (data & 0x3e0) << 6 | (data & 0x380) << 1 + | (data & 0x1f) << 19 | (data & 0x1c) << 14 + | 0xff000000; #else - /* swap endianness first */ - data = s[0] | s[1] << 8; - s += 2; - *o++ = (data & 0x7c00) << 17 | (data & 0x7000) << 12 - | (data & 0x3e0) << 14 | (data & 0x380) << 9 - | (data & 0x1f) << 11 | (data & 0x1c) << 6 - | 0xff; + /* swap endianness first */ + data = s[0] | s[1] << 8; + s += 2; + *o++ = (data & 0x7c00) << 17 | (data & 0x7000) << 12 + | (data & 0x3e0) << 14 | (data & 0x380) << 9 + | (data & 0x1f) << 11 | (data & 0x1c) << 6 + | 0xff; #endif - } - srow += bpl; - orow += rowstride; } + srow += bpl; + orow += rowstride; + } } /* - convert 15 bits/pixel data - with alpha - data in msb format -*/ + * convert 15 bits/pixel data + * with alpha + * data in msb format + */ static void -rgb555amsb (GdkImage *image, guchar *pixels, int rowstride, GdkColormap *colormap) +rgb555amsb (GdkImage *image, + guchar *pixels, + int rowstride, + GdkColormap *colormap) { - int xx, yy; - int width, height; - int bpl; + int xx, yy; + int width, height; + int bpl; #ifdef LITTLE - register guint16 *s; /* read 1 pixels at once */ + register guint16 *s; /* read 1 pixels at once */ #else - register guint8 *s; + register guint8 *s; #endif - register guint32 *o; + register guint32 *o; - guint8 *srow = image->mem, *orow = pixels; + guint8 *srow = image->mem, *orow = pixels; - width = image->width; - height = image->height; - bpl = image->bpl; + width = image->width; + height = image->height; + bpl = image->bpl; - for (yy = 0; yy < height; yy++) { + for (yy = 0; yy < height; yy++) + { #ifdef LITTLE - s = (guint16 *) srow; + s = (guint16 *) srow; #else - s = srow; + s = srow; #endif - o = (guint32 *) orow; - for (xx = 0; xx < width; xx++) { - register guint32 data; - /* rrrrrggg gggbbbbb -> rrrrrRRR gggggGGG bbbbbBBB aaaaaaaa */ - /* little endian: aaaaaaaa bbbbbBBB gggggGGG rrrrrRRR */ + o = (guint32 *) orow; + for (xx = 0; xx < width; xx++) + { + register guint32 data; + /* rrrrrggg gggbbbbb -> rrrrrRRR gggggGGG bbbbbBBB aaaaaaaa */ + /* little endian: aaaaaaaa bbbbbBBB gggggGGG rrrrrRRR */ #ifdef LITTLE - /* swap endianness first */ - data = s[0] | s[1] << 8; - s += 2; - *o++ = (data & 0x7c00) >> 7 | (data & 0x7000) >> 12 - | (data & 0x3e0) << 6 | (data & 0x380) << 1 - | (data & 0x1f) << 19 | (data & 0x1c) << 14 - | 0xff000000; + /* swap endianness first */ + data = s[0] | s[1] << 8; + s += 2; + *o++ = (data & 0x7c00) >> 7 | (data & 0x7000) >> 12 + | (data & 0x3e0) << 6 | (data & 0x380) << 1 + | (data & 0x1f) << 19 | (data & 0x1c) << 14 + | 0xff000000; #else - data = *s++; - *o++ = (data & 0x7c00) << 17 | (data & 0x7000) << 12 - | (data & 0x3e0) << 14 | (data & 0x380) << 9 - | (data & 0x1f) << 11 | (data & 0x1c) << 6 - | 0xff; + data = *s++; + *o++ = (data & 0x7c00) << 17 | (data & 0x7000) << 12 + | (data & 0x3e0) << 14 | (data & 0x380) << 9 + | (data & 0x1f) << 11 | (data & 0x1c) << 6 + | 0xff; #endif - } - srow += bpl; - orow += rowstride; } + srow += bpl; + orow += rowstride; + } } static void -rgb888alsb (GdkImage *image, guchar *pixels, int rowstride, GdkColormap *colormap) +rgb888alsb (GdkImage *image, + guchar *pixels, + int rowstride, + GdkColormap *colormap) { - int xx, yy; - int width, height; - int bpl; - - guint8 *s; /* for byte order swapping */ - guint8 *o; - guint8 *srow = image->mem, *orow = pixels; - - width = image->width; - height = image->height; - bpl = image->bpl; - - d (printf ("32 bits/pixel with alpha\n")); - - /* lsb data */ - for (yy = 0; yy < height; yy++) { - s = srow; - o = orow; - for (xx = 0; xx < width; xx++) { - *o++ = s[2]; - *o++ = s[1]; - *o++ = s[0]; - *o++ = 0xff; - s += 4; - } - srow += bpl; - orow += rowstride; + int xx, yy; + int width, height; + int bpl; + + guint8 *s; /* for byte order swapping */ + guint8 *o; + guint8 *srow = image->mem, *orow = pixels; + + width = image->width; + height = image->height; + bpl = image->bpl; + + d (printf ("32 bits/pixel with alpha\n")); + + /* lsb data */ + for (yy = 0; yy < height; yy++) + { + s = srow; + o = orow; + for (xx = 0; xx < width; xx++) + { + *o++ = s[2]; + *o++ = s[1]; + *o++ = s[0]; + *o++ = 0xff; + s += 4; } + srow += bpl; + orow += rowstride; + } } static void -rgb888lsb (GdkImage *image, guchar *pixels, int rowstride, GdkColormap *colormap) +rgb888lsb (GdkImage *image, + guchar *pixels, + int rowstride, + GdkColormap *colormap) { - int xx, yy; - int width, height; - int bpl; - - guint8 *srow = image->mem, *orow = pixels; - guint8 *o, *s; - - width = image->width; - height = image->height; - bpl = image->bpl; - - d (printf ("32 bit, lsb, no alpha\n")); - - for (yy = 0; yy < height; yy++) { - s = srow; - o = orow; - for (xx = 0; xx < width; xx++) { - *o++ = s[2]; - *o++ = s[1]; - *o++ = s[0]; - s += 4; - } - srow += bpl; - orow += rowstride; + int xx, yy; + int width, height; + int bpl; + + guint8 *srow = image->mem, *orow = pixels; + guint8 *o, *s; + + width = image->width; + height = image->height; + bpl = image->bpl; + + d (printf ("32 bit, lsb, no alpha\n")); + + for (yy = 0; yy < height; yy++) + { + s = srow; + o = orow; + for (xx = 0; xx < width; xx++) + { + *o++ = s[2]; + *o++ = s[1]; + *o++ = s[0]; + s += 4; } + srow += bpl; + orow += rowstride; + } } static void -rgb888amsb (GdkImage *image, guchar *pixels, int rowstride, GdkColormap *colormap) +rgb888amsb (GdkImage *image, + guchar *pixels, + int rowstride, + GdkColormap *colormap) { - int xx, yy; - int width, height; - int bpl; + int xx, yy; + int width, height; + int bpl; - guint8 *srow = image->mem, *orow = pixels; + guint8 *srow = image->mem, *orow = pixels; #ifdef LITTLE - guint32 *o; - guint32 *s; + guint32 *o; + guint32 *s; #else - guint8 *s; /* for byte order swapping */ - guint8 *o; + guint8 *s; /* for byte order swapping */ + guint8 *o; #endif - d (printf ("32 bit, msb, with alpha\n")); + d (printf ("32 bit, msb, with alpha\n")); - width = image->width; - height = image->height; - bpl = image->bpl; + width = image->width; + height = image->height; + bpl = image->bpl; - /* msb data */ - for (yy = 0; yy < height; yy++) { + /* msb data */ + for (yy = 0; yy < height; yy++) + { #ifdef LITTLE - s = (guint32 *) srow; - o = (guint32 *) orow; + s = (guint32 *) srow; + o = (guint32 *) orow; #else - s = srow; - o = orow; + s = srow; + o = orow; #endif - for (xx = 0; xx < width; xx++) { + for (xx = 0; xx < width; xx++) + { #ifdef LITTLE - *o++ = s[1]; - *o++ = s[2]; - *o++ = s[3]; - *o++ = 0xff; - s += 4; + *o++ = s[1]; + *o++ = s[2]; + *o++ = s[3]; + *o++ = 0xff; + s += 4; #else - *o++ = (*s << 8) | 0xff; /* untested */ - s++; + *o++ = (*s << 8) | 0xff; /* untested */ + s++; #endif - } - srow += bpl; - orow += rowstride; } + srow += bpl; + orow += rowstride; + } } static void -rgb888msb (GdkImage *image, guchar *pixels, int rowstride, GdkColormap *colormap) +rgb888msb (GdkImage *image, + guchar *pixels, + int rowstride, + GdkColormap *colormap) { - int xx, yy; - int width, height; - int bpl; - - guint8 *srow = image->mem, *orow = pixels; - guint8 *s; - guint8 *o; - - d (printf ("32 bit, msb, no alpha\n")); - - width = image->width; - height = image->height; - bpl = image->bpl; - - for (yy = 0; yy < height; yy++) { - s = srow; - o = orow; - for (xx = 0; xx < width; xx++) { - *o++ = s[1]; - *o++ = s[2]; - *o++ = s[3]; - s += 4; - } - srow += bpl; - orow += rowstride; + int xx, yy; + int width, height; + int bpl; + + guint8 *srow = image->mem, *orow = pixels; + guint8 *s; + guint8 *o; + + d (printf ("32 bit, msb, no alpha\n")); + + width = image->width; + height = image->height; + bpl = image->bpl; + + for (yy = 0; yy < height; yy++) + { + s = srow; + o = orow; + for (xx = 0; xx < width; xx++) + { + *o++ = s[1]; + *o++ = s[2]; + *o++ = s[3]; + s += 4; } + srow += bpl; + orow += rowstride; + } } /* - This should work correctly with any display/any endianness, but will probably - run quite slow -*/ + * This should work correctly with any display/any endianness, but will probably + * run quite slow + */ static void -convert_real_slow (GdkImage *image, guchar *pixels, int rowstride, GdkColormap *cmap, int alpha) +convert_real_slow (GdkImage *image, + guchar *pixels, + int rowstride, + GdkColormap *cmap, + int alpha) { - int xx, yy; - int width, height; - int bpl; - guint8 *srow = image->mem, *orow = pixels; - guint8 *s; - guint8 *o; - guint32 pixel; - GdkVisual *v; - guint8 component; - int i; - - width = image->width; - height = image->height; - bpl = image->bpl; - v = gdk_colormap_get_visual(cmap); - - d(printf("rgb mask/shift/prec = %x:%x:%x %d:%d:%d %d:%d:%d\n", - v->red_mask, v->green_mask, v->blue_mask, - v->red_shift, v->green_shift, v->blue_shift, - v->red_prec, v->green_prec, v->blue_prec)); - - for (yy = 0; yy < height; yy++) { - s = srow; - o = orow; - for (xx = 0; xx < width; xx++) { - pixel = gdk_image_get_pixel(image, xx, yy); - switch (v->type) { + int xx, yy; + int width, height; + int bpl; + guint8 *srow = image->mem, *orow = pixels; + guint8 *s; + guint8 *o; + guint32 pixel; + GdkVisual *v; + guint8 component; + int i; + + width = image->width; + height = image->height; + bpl = image->bpl; + v = gdk_colormap_get_visual(cmap); + + d(printf("rgb mask/shift/prec = %x:%x:%x %d:%d:%d %d:%d:%d\n", + v->red_mask, v->green_mask, v->blue_mask, + v->red_shift, v->green_shift, v->blue_shift, + v->red_prec, v->green_prec, v->blue_prec)); + + for (yy = 0; yy < height; yy++) + { + s = srow; + o = orow; + for (xx = 0; xx < width; xx++) + { + pixel = gdk_image_get_pixel(image, xx, yy); + switch (v->type) + { /* I assume this is right for static & greyscale's too? */ - case GDK_VISUAL_STATIC_GRAY: - case GDK_VISUAL_GRAYSCALE: - case GDK_VISUAL_STATIC_COLOR: - case GDK_VISUAL_PSEUDO_COLOR: - *o++ = cmap->colors[pixel].red; - *o++ = cmap->colors[pixel].green; - *o++ = cmap->colors[pixel].blue; - break; - case GDK_VISUAL_TRUE_COLOR: + case GDK_VISUAL_STATIC_GRAY: + case GDK_VISUAL_GRAYSCALE: + case GDK_VISUAL_STATIC_COLOR: + case GDK_VISUAL_PSEUDO_COLOR: + *o++ = cmap->colors[pixel].red; + *o++ = cmap->colors[pixel].green; + *o++ = cmap->colors[pixel].blue; + break; + case GDK_VISUAL_TRUE_COLOR: /* This is odd because it must sometimes shift left (otherwise - I'd just shift >> (*_shift - 8 + *_prec + <0-7>). This logic - should work for all bit sizes/shifts/etc. */ - component = 0; - for (i = 24; i < 32; i += v->red_prec) - component |= ((pixel & v->red_mask) << (32 - v->red_shift - v->red_prec)) >> i; - *o++ = component; - component = 0; - for (i = 24; i < 32; i += v->green_prec) - component |= ((pixel & v->green_mask) << (32 - v->green_shift - v->green_prec)) >> i; - *o++ = component; - component = 0; - for (i = 24; i < 32; i += v->blue_prec) - component |= ((pixel & v->blue_mask) << (32 - v->blue_shift - v->blue_prec)) >> i; - *o++ = component; - break; - case GDK_VISUAL_DIRECT_COLOR: - *o++ = cmap->colors[((pixel & v->red_mask) << (32 - v->red_shift - v->red_prec)) >> 24].red; - *o++ = cmap->colors[((pixel & v->green_mask) << (32 - v->green_shift - v->green_prec)) >> 24].green; - *o++ = cmap->colors[((pixel & v->blue_mask) << (32 - v->blue_shift - v->blue_prec)) >> 24].blue; - break; - } - if (alpha) - *o++ = 0xff; - } - srow += bpl; - orow += rowstride; + * I'd just shift >> (*_shift - 8 + *_prec + <0-7>). This logic + * should work for all bit sizes/shifts/etc. + */ + component = 0; + for (i = 24; i < 32; i += v->red_prec) + component |= ((pixel & v->red_mask) << (32 - v->red_shift - v->red_prec)) >> i; + *o++ = component; + component = 0; + for (i = 24; i < 32; i += v->green_prec) + component |= ((pixel & v->green_mask) << (32 - v->green_shift - v->green_prec)) >> i; + *o++ = component; + component = 0; + for (i = 24; i < 32; i += v->blue_prec) + component |= ((pixel & v->blue_mask) << (32 - v->blue_shift - v->blue_prec)) >> i; + *o++ = component; + break; + case GDK_VISUAL_DIRECT_COLOR: + *o++ = cmap->colors[((pixel & v->red_mask) << (32 - v->red_shift - v->red_prec)) >> 24].red; + *o++ = cmap->colors[((pixel & v->green_mask) << (32 - v->green_shift - v->green_prec)) >> 24].green; + *o++ = cmap->colors[((pixel & v->blue_mask) << (32 - v->blue_shift - v->blue_prec)) >> 24].blue; + break; + } + if (alpha) + *o++ = 0xff; } + srow += bpl; + orow += rowstride; + } } typedef void (* cfunc) (GdkImage *image, guchar *pixels, int rowstride, GdkColormap *cmap); static cfunc convert_map[] = { - rgb1,rgb1,rgb1a,rgb1a, - rgb8,rgb8,rgb8a,rgb8a, - rgb555lsb,rgb555msb,rgb555alsb,rgb555amsb, - rgb565lsb,rgb565msb,rgb565alsb,rgb565amsb, - rgb888lsb,rgb888msb,rgb888alsb,rgb888amsb + rgb1,rgb1,rgb1a,rgb1a, + rgb8,rgb8,rgb8a,rgb8a, + rgb555lsb,rgb555msb,rgb555alsb,rgb555amsb, + rgb565lsb,rgb565msb,rgb565alsb,rgb565amsb, + rgb888lsb,rgb888msb,rgb888alsb,rgb888amsb }; /* - perform actual conversion - - If we can, try and use the optimised code versions, but as a default - fallback, and always for direct colour, use the generic/slow but complete - conversion function. -*/ + * perform actual conversion + * + * If we can, try and use the optimised code versions, but as a default + * fallback, and always for direct colour, use the generic/slow but complete + * conversion function. + */ static void -rgbconvert (GdkImage *image, guchar *pixels, int rowstride, int alpha, GdkColormap *cmap) +rgbconvert (GdkImage *image, + guchar *pixels, + int rowstride, + int alpha, + GdkColormap *cmap) { - int index = (image->byte_order == GDK_MSB_FIRST) | (alpha != 0) << 1; - int bank=5; /* default fallback converter */ - GdkVisual *v = gdk_colormap_get_visual(cmap); + int index = (image->byte_order == GDK_MSB_FIRST) | (alpha != 0) << 1; + int bank=5; /* default fallback converter */ + GdkVisual *v = gdk_colormap_get_visual(cmap); - d(printf("masks = %x:%x:%x\n", v->red_mask, v->green_mask, v->blue_mask)); - d(printf("image depth = %d, bpp = %d\n", image->depth, image->bpp)); + d(printf("masks = %x:%x:%x\n", v->red_mask, v->green_mask, v->blue_mask)); + d(printf("image depth = %d, bpp = %d\n", image->depth, image->bpp)); - switch (v->type) { + switch (v->type) + { /* I assume this is right for static & greyscale's too? */ - case GDK_VISUAL_STATIC_GRAY: - case GDK_VISUAL_GRAYSCALE: - case GDK_VISUAL_STATIC_COLOR: - case GDK_VISUAL_PSEUDO_COLOR: - switch (image->bpp) { - case 1: - bank = 0; - break; - case 8: - bank = 1; - break; - } - break; - case GDK_VISUAL_TRUE_COLOR: - switch (image->depth) { - case 15: - if (v->red_mask == 0x7c00 && v->green_mask == 0x3e0 && v->blue_mask == 0x1f - && image->bpp == 16) - bank = 2; - break; - case 16: - if (v->red_mask == 0xf800 && v->green_mask == 0x7e0 && v->blue_mask == 0x1f - && image->bpp == 16) - bank = 3; - break; - case 24: - case 32: - if (v->red_mask == 0xff0000 && v->green_mask == 0xff00 && v->blue_mask == 0xff - && image->bpp == 32) - bank = 4; - break; - } - break; - case GDK_VISUAL_DIRECT_COLOR: - /* always use the slow version */ - break; + case GDK_VISUAL_STATIC_GRAY: + case GDK_VISUAL_GRAYSCALE: + case GDK_VISUAL_STATIC_COLOR: + case GDK_VISUAL_PSEUDO_COLOR: + switch (image->bpp) + { + case 1: + bank = 0; + break; + case 8: + bank = 1; + break; } - - d(printf("converting using conversion function in bank %d\n", bank)); - - if (bank==5) { - convert_real_slow(image, pixels, rowstride, cmap, alpha); - } else { - index |= bank << 2; - (* convert_map[index]) (image, pixels, rowstride, cmap); + break; + case GDK_VISUAL_TRUE_COLOR: + switch (image->depth) + { + case 15: + if (v->red_mask == 0x7c00 && v->green_mask == 0x3e0 && v->blue_mask == 0x1f + && image->bpp == 16) + bank = 2; + break; + case 16: + if (v->red_mask == 0xf800 && v->green_mask == 0x7e0 && v->blue_mask == 0x1f + && image->bpp == 16) + bank = 3; + break; + case 24: + case 32: + if (v->red_mask == 0xff0000 && v->green_mask == 0xff00 && v->blue_mask == 0xff + && image->bpp == 32) + bank = 4; + break; } + break; + case GDK_VISUAL_DIRECT_COLOR: + /* always use the slow version */ + break; + } + + d(printf("converting using conversion function in bank %d\n", bank)); + + if (bank==5) + { + convert_real_slow(image, pixels, rowstride, cmap, alpha); + } + else + { + index |= bank << 2; + (* convert_map[index]) (image, pixels, rowstride, cmap); + } } @@ -1082,100 +1185,106 @@ rgbconvert (GdkImage *image, guchar *pixels, int rowstride, int alpha, GdkColorm * allocated for the pixbuf to be created. **/ GdkPixbuf * -gdk_pixbuf_get_from_drawable (GdkPixbuf *dest, - GdkDrawable *src, GdkColormap *cmap, - int src_x, int src_y, +gdk_pixbuf_get_from_drawable (GdkPixbuf *dest, + GdkDrawable *src, + GdkColormap *cmap, + int src_x, int src_y, int dest_x, int dest_y, - int width, int height) + int width, int height) { - int src_width, src_height; - GdkImage *image; - int rowstride, bpp, alpha; - - /* General sanity checks */ - - g_return_val_if_fail (src != NULL, NULL); - - if (GDK_IS_PIXMAP (src)) - g_return_val_if_fail (cmap != NULL, NULL); - else - /* FIXME: this is not perfect, since is_viewable() only tests - * recursively up the Gdk parent window tree, but stops at - * foreign windows or Gdk toplevels. I.e. if a window manager - * unmapped one of its own windows, this won't work. - */ - g_return_val_if_fail (gdk_window_is_viewable (src), NULL); - - if (!dest) - g_return_val_if_fail (dest_x == 0 && dest_y == 0, NULL); - else { - g_return_val_if_fail (dest->colorspace == GDK_COLORSPACE_RGB, NULL); - g_return_val_if_fail (dest->n_channels == 3 || dest->n_channels == 4, NULL); - g_return_val_if_fail (dest->bits_per_sample == 8, NULL); - } - - /* Coordinate sanity checks */ - - gdk_drawable_get_size (src, &src_width, &src_height); - - g_return_val_if_fail (src_x >= 0 && src_y >= 0, NULL); - g_return_val_if_fail (src_x + width <= src_width && src_y + height <= src_height, NULL); - - if (dest) { - g_return_val_if_fail (dest_x >= 0 && dest_y >= 0, NULL); - g_return_val_if_fail (dest_x + width <= dest->width, NULL); - g_return_val_if_fail (dest_y + height <= dest->height, NULL); - } - - if (!GDK_IS_PIXMAP (src)) { - int ret; - int src_xorigin, src_yorigin; - int screen_width, screen_height; - int screen_srcx, screen_srcy; - - ret = gdk_window_get_origin (src, &src_xorigin, &src_yorigin); - g_return_val_if_fail (ret != FALSE, NULL); - - screen_width = gdk_screen_width (); - screen_height = gdk_screen_height (); - - screen_srcx = src_xorigin + src_x; - screen_srcy = src_yorigin + src_y; - - g_return_val_if_fail (screen_srcx >= 0 && screen_srcy >= 0, NULL); - g_return_val_if_fail (screen_srcx + width <= screen_width, NULL); - g_return_val_if_fail (screen_srcy + height <= screen_height, NULL); - } - - /* Get Image in ZPixmap format (packed bits). */ - image = gdk_image_get (src, src_x, src_y, width, height); - g_return_val_if_fail (image != NULL, NULL); - - /* Create the pixbuf if needed */ - if (!dest) { - dest = gdk_pixbuf_new (GDK_COLORSPACE_RGB, FALSE, 8, width, height); - if (!dest) { - gdk_image_destroy(image); - return NULL; - } + int src_width, src_height; + GdkImage *image; + int rowstride, bpp, alpha; + + /* General sanity checks */ + + g_return_val_if_fail (src != NULL, NULL); + + if (GDK_IS_PIXMAP (src)) + g_return_val_if_fail (cmap != NULL, NULL); + else + /* FIXME: this is not perfect, since is_viewable() only tests + * recursively up the Gdk parent window tree, but stops at + * foreign windows or Gdk toplevels. I.e. if a window manager + * unmapped one of its own windows, this won't work. + */ + g_return_val_if_fail (gdk_window_is_viewable (src), NULL); + + if (!dest) + g_return_val_if_fail (dest_x == 0 && dest_y == 0, NULL); + else + { + g_return_val_if_fail (dest->colorspace == GDK_COLORSPACE_RGB, NULL); + g_return_val_if_fail (dest->n_channels == 3 || dest->n_channels == 4, NULL); + g_return_val_if_fail (dest->bits_per_sample == 8, NULL); + } + + /* Coordinate sanity checks */ + + gdk_drawable_get_size (src, &src_width, &src_height); + + g_return_val_if_fail (src_x >= 0 && src_y >= 0, NULL); + g_return_val_if_fail (src_x + width <= src_width && src_y + height <= src_height, NULL); + + if (dest) + { + g_return_val_if_fail (dest_x >= 0 && dest_y >= 0, NULL); + g_return_val_if_fail (dest_x + width <= dest->width, NULL); + g_return_val_if_fail (dest_y + height <= dest->height, NULL); + } + + if (!GDK_IS_PIXMAP (src)) + { + int ret; + int src_xorigin, src_yorigin; + int screen_width, screen_height; + int screen_srcx, screen_srcy; + + ret = gdk_window_get_origin (src, &src_xorigin, &src_yorigin); + g_return_val_if_fail (ret != FALSE, NULL); + + screen_width = gdk_screen_width (); + screen_height = gdk_screen_height (); + + screen_srcx = src_xorigin + src_x; + screen_srcy = src_yorigin + src_y; + + g_return_val_if_fail (screen_srcx >= 0 && screen_srcy >= 0, NULL); + g_return_val_if_fail (screen_srcx + width <= screen_width, NULL); + g_return_val_if_fail (screen_srcy + height <= screen_height, NULL); + } + + /* Get Image in ZPixmap format (packed bits). */ + image = gdk_image_get (src, src_x, src_y, width, height); + g_return_val_if_fail (image != NULL, NULL); + + /* Create the pixbuf if needed */ + if (!dest) + { + dest = gdk_pixbuf_new (GDK_COLORSPACE_RGB, FALSE, 8, width, height); + if (!dest) + { + gdk_image_destroy(image); + return NULL; } + } - /* Get the colormap if needed */ - if (!GDK_IS_PIXMAP (src)) - cmap = gdk_window_get_colormap (src); + /* Get the colormap if needed */ + if (!GDK_IS_PIXMAP (src)) + cmap = gdk_window_get_colormap (src); - alpha = dest->has_alpha; - rowstride = dest->rowstride; - bpp = alpha ? 4 : 3; + alpha = dest->has_alpha; + rowstride = dest->rowstride; + bpp = alpha ? 4 : 3; - /* we offset into the image data based on the position we are retrieving from */ - rgbconvert (image, dest->pixels + - (dest_y * rowstride) + (dest_x * bpp), - rowstride, - alpha, - cmap); + /* we offset into the image data based on the position we are retrieving from */ + rgbconvert (image, dest->pixels + + (dest_y * rowstride) + (dest_x * bpp), + rowstride, + alpha, + cmap); - gdk_image_destroy(image); + gdk_image_destroy(image); - return dest; + return dest; } diff --git a/gdk/gdkpixbuf-render.c b/gdk/gdkpixbuf-render.c index 0d47ac0cd3..545f91123b 100644 --- a/gdk/gdkpixbuf-render.c +++ b/gdk/gdkpixbuf-render.c @@ -46,116 +46,126 @@ * **/ void -gdk_pixbuf_render_threshold_alpha (GdkPixbuf *pixbuf, GdkBitmap *bitmap, - int src_x, int src_y, +gdk_pixbuf_render_threshold_alpha (GdkPixbuf *pixbuf, + GdkBitmap *bitmap, + int src_x, int src_y, int dest_x, int dest_y, - int width, int height, + int width, int height, int alpha_threshold) { - GdkGC *gc; - GdkColor color; - int x, y; - guchar *p; - int start, start_status; - int status; - - g_return_if_fail (pixbuf != NULL); - g_return_if_fail (pixbuf->colorspace == GDK_COLORSPACE_RGB); - g_return_if_fail (pixbuf->n_channels == 3 || pixbuf->n_channels == 4); - g_return_if_fail (pixbuf->bits_per_sample == 8); - - g_return_if_fail (bitmap != NULL); - g_return_if_fail (width >= 0 && height >= 0); - g_return_if_fail (src_x >= 0 && src_x + width <= pixbuf->width); - g_return_if_fail (src_y >= 0 && src_y + height <= pixbuf->height); - - g_return_if_fail (alpha_threshold >= 0 && alpha_threshold <= 255); - - if (width == 0 || height == 0) - return; - - gc = gdk_gc_new (bitmap); - - if (!pixbuf->has_alpha) { - color.pixel = (alpha_threshold == 255) ? 0 : 1; - gdk_gc_set_foreground (gc, &color); - gdk_draw_rectangle (bitmap, gc, TRUE, dest_x, dest_y, width, height); - gdk_gc_unref (gc); - return; + GdkGC *gc; + GdkColor color; + int x, y; + guchar *p; + int start, start_status; + int status; + + g_return_if_fail (pixbuf != NULL); + g_return_if_fail (pixbuf->colorspace == GDK_COLORSPACE_RGB); + g_return_if_fail (pixbuf->n_channels == 3 || pixbuf->n_channels == 4); + g_return_if_fail (pixbuf->bits_per_sample == 8); + + g_return_if_fail (bitmap != NULL); + g_return_if_fail (width >= 0 && height >= 0); + g_return_if_fail (src_x >= 0 && src_x + width <= pixbuf->width); + g_return_if_fail (src_y >= 0 && src_y + height <= pixbuf->height); + + g_return_if_fail (alpha_threshold >= 0 && alpha_threshold <= 255); + + if (width == 0 || height == 0) + return; + + gc = gdk_gc_new (bitmap); + + if (!pixbuf->has_alpha) + { + color.pixel = (alpha_threshold == 255) ? 0 : 1; + gdk_gc_set_foreground (gc, &color); + gdk_draw_rectangle (bitmap, gc, TRUE, dest_x, dest_y, width, height); + gdk_gc_unref (gc); + return; + } + + color.pixel = 0; + gdk_gc_set_foreground (gc, &color); + gdk_draw_rectangle (bitmap, gc, TRUE, dest_x, dest_y, width, height); + + color.pixel = 1; + gdk_gc_set_foreground (gc, &color); + + for (y = 0; y < height; y++) + { + p = (pixbuf->pixels + (y + src_y) * pixbuf->rowstride + src_x * pixbuf->n_channels + + pixbuf->n_channels - 1); + + start = 0; + start_status = *p < alpha_threshold; + + for (x = 0; x < width; x++) + { + status = *p < alpha_threshold; + + if (status != start_status) + { + if (!start_status) + gdk_draw_line (bitmap, gc, + start + dest_x, y + dest_y, + x - 1 + dest_x, y + dest_y); + + start = x; + start_status = status; + } + + p += pixbuf->n_channels; } - - color.pixel = 0; - gdk_gc_set_foreground (gc, &color); - gdk_draw_rectangle (bitmap, gc, TRUE, dest_x, dest_y, width, height); - - color.pixel = 1; - gdk_gc_set_foreground (gc, &color); - - for (y = 0; y < height; y++) { - p = (pixbuf->pixels + (y + src_y) * pixbuf->rowstride + src_x * pixbuf->n_channels - + pixbuf->n_channels - 1); - - start = 0; - start_status = *p < alpha_threshold; - - for (x = 0; x < width; x++) { - status = *p < alpha_threshold; - - if (status != start_status) { - if (!start_status) - gdk_draw_line (bitmap, gc, - start + dest_x, y + dest_y, - x - 1 + dest_x, y + dest_y); - - start = x; - start_status = status; - } - - p += pixbuf->n_channels; - } - - if (!start_status) - gdk_draw_line (bitmap, gc, - start + dest_x, y + dest_y, - x - 1 + dest_x, y + dest_y); - } - - gdk_gc_unref (gc); + + if (!start_status) + gdk_draw_line (bitmap, gc, + start + dest_x, y + dest_y, + x - 1 + dest_x, y + dest_y); + } + + gdk_gc_unref (gc); } /* Creates a buffer by stripping the alpha channel of a pixbuf */ static guchar * -remove_alpha (GdkPixbuf *pixbuf, int x, int y, int width, int height, int *rowstride) +remove_alpha (GdkPixbuf *pixbuf, + int x, int y, + int width, int height, + int *rowstride) { - guchar *buf; - int xx, yy; - guchar *src, *dest; - - g_assert (pixbuf->n_channels == 4); - g_assert (pixbuf->has_alpha); - g_assert (width > 0 && height > 0); - g_assert (x >= 0 && x + width <= pixbuf->width); - g_assert (y >= 0 && y + height <= pixbuf->height); - - *rowstride = 4 * ((width * 3 + 3) / 4); - - buf = g_new (guchar, *rowstride * height); - - for (yy = 0; yy < height; yy++) { - src = pixbuf->pixels + pixbuf->rowstride * (yy + y) + x * pixbuf->n_channels; - dest = buf + *rowstride * yy; - - for (xx = 0; xx < width; xx++) { - *dest++ = *src++; - *dest++ = *src++; - *dest++ = *src++; - src++; - } + guchar *buf; + int xx, yy; + guchar *src, *dest; + + g_assert (pixbuf->n_channels == 4); + g_assert (pixbuf->has_alpha); + g_assert (width > 0 && height > 0); + g_assert (x >= 0 && x + width <= pixbuf->width); + g_assert (y >= 0 && y + height <= pixbuf->height); + + *rowstride = 4 * ((width * 3 + 3) / 4); + + buf = g_new (guchar, *rowstride * height); + + for (yy = 0; yy < height; yy++) + { + src = pixbuf->pixels + pixbuf->rowstride * (yy + y) + x * pixbuf->n_channels; + dest = buf + *rowstride * yy; + + for (xx = 0; xx < width; xx++) + { + *dest++ = *src++; + *dest++ = *src++; + *dest++ = *src++; + src++; } - - return buf; + } + + return buf; } /** @@ -187,53 +197,55 @@ remove_alpha (GdkPixbuf *pixbuf, int x, int y, int width, int height, int *rowst * dither offsets can be both zero. **/ void -gdk_pixbuf_render_to_drawable (GdkPixbuf *pixbuf, - GdkDrawable *drawable, GdkGC *gc, - int src_x, int src_y, - int dest_x, int dest_y, - int width, int height, +gdk_pixbuf_render_to_drawable (GdkPixbuf *pixbuf, + GdkDrawable *drawable, + GdkGC *gc, + int src_x, int src_y, + int dest_x, int dest_y, + int width, int height, GdkRgbDither dither, int x_dither, int y_dither) { - guchar *buf; - int rowstride; - - g_return_if_fail (pixbuf != NULL); - g_return_if_fail (pixbuf->colorspace == GDK_COLORSPACE_RGB); - g_return_if_fail (pixbuf->n_channels == 3 || pixbuf->n_channels == 4); - g_return_if_fail (pixbuf->bits_per_sample == 8); - - g_return_if_fail (drawable != NULL); - g_return_if_fail (gc != NULL); - - g_return_if_fail (width >= 0 && height >= 0); - g_return_if_fail (src_x >= 0 && src_x + width <= pixbuf->width); - g_return_if_fail (src_y >= 0 && src_y + height <= pixbuf->height); - - if (width == 0 || height == 0) - return; - - /* This will have to be modified once we support other image types. - * Also, GdkRGB does not have gdk_draw_rgb_32_image_dithalign(), so we - * have to pack the buffer first. Sigh. - */ - - if (pixbuf->has_alpha) - buf = remove_alpha (pixbuf, src_x, src_y, width, height, &rowstride); - else { - buf = pixbuf->pixels + src_y * pixbuf->rowstride + src_x * 3; - rowstride = pixbuf->rowstride; - } - - gdk_draw_rgb_image_dithalign (drawable, gc, - dest_x, dest_y, - width, height, - dither, - buf, rowstride, - x_dither, y_dither); - - if (pixbuf->has_alpha) - g_free (buf); + guchar *buf; + int rowstride; + + g_return_if_fail (pixbuf != NULL); + g_return_if_fail (pixbuf->colorspace == GDK_COLORSPACE_RGB); + g_return_if_fail (pixbuf->n_channels == 3 || pixbuf->n_channels == 4); + g_return_if_fail (pixbuf->bits_per_sample == 8); + + g_return_if_fail (drawable != NULL); + g_return_if_fail (gc != NULL); + + g_return_if_fail (width >= 0 && height >= 0); + g_return_if_fail (src_x >= 0 && src_x + width <= pixbuf->width); + g_return_if_fail (src_y >= 0 && src_y + height <= pixbuf->height); + + if (width == 0 || height == 0) + return; + + /* This will have to be modified once we support other image types. + * Also, GdkRGB does not have gdk_draw_rgb_32_image_dithalign(), so we + * have to pack the buffer first. Sigh. + */ + + if (pixbuf->has_alpha) + buf = remove_alpha (pixbuf, src_x, src_y, width, height, &rowstride); + else + { + buf = pixbuf->pixels + src_y * pixbuf->rowstride + src_x * 3; + rowstride = pixbuf->rowstride; + } + + gdk_draw_rgb_image_dithalign (drawable, gc, + dest_x, dest_y, + width, height, + dither, + buf, rowstride, + x_dither, y_dither); + + if (pixbuf->has_alpha) + g_free (buf); } @@ -269,60 +281,62 @@ gdk_pixbuf_render_to_drawable (GdkPixbuf *pixbuf, * using gdk_pixbuf_render_to_drawable() or GdkRGB directly instead. **/ void -gdk_pixbuf_render_to_drawable_alpha (GdkPixbuf *pixbuf, GdkDrawable *drawable, - int src_x, int src_y, - int dest_x, int dest_y, - int width, int height, +gdk_pixbuf_render_to_drawable_alpha (GdkPixbuf *pixbuf, + GdkDrawable *drawable, + int src_x, int src_y, + int dest_x, int dest_y, + int width, int height, GdkPixbufAlphaMode alpha_mode, - int alpha_threshold, - GdkRgbDither dither, + int alpha_threshold, + GdkRgbDither dither, int x_dither, int y_dither) { - GdkBitmap *bitmap = NULL; - GdkGC *gc; - - g_return_if_fail (pixbuf != NULL); - g_return_if_fail (pixbuf->colorspace == GDK_COLORSPACE_RGB); - g_return_if_fail (pixbuf->n_channels == 3 || pixbuf->n_channels == 4); - g_return_if_fail (pixbuf->bits_per_sample == 8); - - g_return_if_fail (drawable != NULL); - g_return_if_fail (width >= 0 && height >= 0); - g_return_if_fail (src_x >= 0 && src_x + width <= pixbuf->width); - g_return_if_fail (src_y >= 0 && src_y + height <= pixbuf->height); - - if (width == 0 || height == 0) - return; - - gc = gdk_gc_new (drawable); - - if (pixbuf->has_alpha) { - /* Right now we only support GDK_PIXBUF_ALPHA_BILEVEL, so we - * unconditionally create the clipping mask. - */ - - bitmap = gdk_pixmap_new (NULL, width, height, 1); - gdk_pixbuf_render_threshold_alpha (pixbuf, bitmap, - src_x, src_y, - 0, 0, - width, height, - alpha_threshold); - - gdk_gc_set_clip_mask (gc, bitmap); - gdk_gc_set_clip_origin (gc, dest_x, dest_y); - } - - gdk_pixbuf_render_to_drawable (pixbuf, drawable, gc, - src_x, src_y, - dest_x, dest_y, - width, height, - dither, - x_dither, y_dither); - - if (bitmap) - gdk_bitmap_unref (bitmap); - - gdk_gc_unref (gc); + GdkBitmap *bitmap = NULL; + GdkGC *gc; + + g_return_if_fail (pixbuf != NULL); + g_return_if_fail (pixbuf->colorspace == GDK_COLORSPACE_RGB); + g_return_if_fail (pixbuf->n_channels == 3 || pixbuf->n_channels == 4); + g_return_if_fail (pixbuf->bits_per_sample == 8); + + g_return_if_fail (drawable != NULL); + g_return_if_fail (width >= 0 && height >= 0); + g_return_if_fail (src_x >= 0 && src_x + width <= pixbuf->width); + g_return_if_fail (src_y >= 0 && src_y + height <= pixbuf->height); + + if (width == 0 || height == 0) + return; + + gc = gdk_gc_new (drawable); + + if (pixbuf->has_alpha) + { + /* Right now we only support GDK_PIXBUF_ALPHA_BILEVEL, so we + * unconditionally create the clipping mask. + */ + + bitmap = gdk_pixmap_new (NULL, width, height, 1); + gdk_pixbuf_render_threshold_alpha (pixbuf, bitmap, + src_x, src_y, + 0, 0, + width, height, + alpha_threshold); + + gdk_gc_set_clip_mask (gc, bitmap); + gdk_gc_set_clip_origin (gc, dest_x, dest_y); + } + + gdk_pixbuf_render_to_drawable (pixbuf, drawable, gc, + src_x, src_y, + dest_x, dest_y, + width, height, + dither, + x_dither, y_dither); + + if (bitmap) + gdk_bitmap_unref (bitmap); + + gdk_gc_unref (gc); } /** @@ -343,34 +357,39 @@ gdk_pixbuf_render_to_drawable_alpha (GdkPixbuf *pixbuf, GdkDrawable *drawable, * to NULL. **/ void -gdk_pixbuf_render_pixmap_and_mask (GdkPixbuf *pixbuf, - GdkPixmap **pixmap_return, GdkBitmap **mask_return, - int alpha_threshold) +gdk_pixbuf_render_pixmap_and_mask (GdkPixbuf *pixbuf, + GdkPixmap **pixmap_return, + GdkBitmap **mask_return, + int alpha_threshold) { - g_return_if_fail (pixbuf != NULL); - - if (pixmap_return) { - GdkGC *gc; - - *pixmap_return = gdk_pixmap_new (NULL, pixbuf->width, pixbuf->height, - gdk_rgb_get_visual ()->depth); - gc = gdk_gc_new (*pixmap_return); - gdk_pixbuf_render_to_drawable (pixbuf, *pixmap_return, gc, - 0, 0, 0, 0, - pixbuf->width, pixbuf->height, - GDK_RGB_DITHER_NORMAL, - 0, 0); - gdk_gc_unref (gc); - } - - if (mask_return) { - if (pixbuf->has_alpha) { - *mask_return = gdk_pixmap_new (NULL, pixbuf->width, pixbuf->height, 1); - gdk_pixbuf_render_threshold_alpha (pixbuf, *mask_return, - 0, 0, 0, 0, - pixbuf->width, pixbuf->height, - alpha_threshold); - } else - *mask_return = NULL; + g_return_if_fail (pixbuf != NULL); + + if (pixmap_return) + { + GdkGC *gc; + + *pixmap_return = gdk_pixmap_new (NULL, pixbuf->width, pixbuf->height, + gdk_rgb_get_visual ()->depth); + gc = gdk_gc_new (*pixmap_return); + gdk_pixbuf_render_to_drawable (pixbuf, *pixmap_return, gc, + 0, 0, 0, 0, + pixbuf->width, pixbuf->height, + GDK_RGB_DITHER_NORMAL, + 0, 0); + gdk_gc_unref (gc); + } + + if (mask_return) + { + if (pixbuf->has_alpha) + { + *mask_return = gdk_pixmap_new (NULL, pixbuf->width, pixbuf->height, 1); + gdk_pixbuf_render_threshold_alpha (pixbuf, *mask_return, + 0, 0, 0, 0, + pixbuf->width, pixbuf->height, + alpha_threshold); } + else + *mask_return = NULL; + } } -- 2.30.2